<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Type Traits</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Iterator">
<link rel="up" href="../utilities.html" title="Utilities">
<link rel="prev" href="iterator_traits.html" title="Iterator Traits">
<link rel="next" href="../algorithms.html" title="Algorithms">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="iterator_traits.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../utilities.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../algorithms.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="iterator.utilities.traits"></a><a class="link" href="traits.html" title="Type Traits">Type Traits</a>
</h3></div></div></div>
<h3>
<a name="iterator.utilities.traits.h0"></a>
        <span class="phrase"><a name="iterator.utilities.traits.overview"></a></span><a class="link" href="traits.html#iterator.utilities.traits.overview">Overview</a>
      </h3>
<p>
        Have you ever wanted to write a generic function that can operate on any
        kind of dereferenceable object? If you have, you've probably run into the
        problem of how to determine the type that the object "points at":
      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Dereferenceable</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Dereferenceable</span> <span class="identifier">p</span><span class="special">)</span>
<span class="special">{</span>
    <span class="special">*</span><span class="identifier">what</span><span class="special">-</span><span class="identifier">goes</span><span class="special">-</span><span class="identifier">here</span><span class="special">?*</span> <span class="identifier">value</span> <span class="special">=</span> <span class="special">\*</span><span class="identifier">p</span><span class="special">;</span>
    <span class="special">...</span>
<span class="special">}</span>
</pre>
<h3>
<a name="iterator.utilities.traits.h1"></a>
        <span class="phrase"><a name="iterator.utilities.traits.pointee"></a></span><a class="link" href="traits.html#iterator.utilities.traits.pointee"><code class="computeroutput"><span class="identifier">pointee</span></code></a>
      </h3>
<p>
        It turns out to be impossible to come up with a fully-general algorithm to
        do determine <span class="bold"><strong>what-goes-here</strong></span> directly, but
        it is possible to require that <code class="computeroutput"><span class="identifier">pointee</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
        is correct. Naturally, <code class="computeroutput"><span class="identifier">pointee</span></code>
        has the same difficulty: it can't determine the appropriate <code class="computeroutput"><span class="special">::</span><span class="identifier">type</span></code>
        reliably for all <code class="computeroutput"><span class="identifier">Dereferenceable</span></code>s,
        but it makes very good guesses (it works for all pointers, standard and boost
        smart pointers, and iterators), and when it guesses wrongly, it can be specialized
        as necessary:
      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">pointee</span><span class="special">&lt;</span><span class="identifier">third_party_lib</span><span class="special">::</span><span class="identifier">smart_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span>
  <span class="special">};</span>
<span class="special">}</span>
</pre>
<h3>
<a name="iterator.utilities.traits.h2"></a>
        <span class="phrase"><a name="iterator.utilities.traits.indirect_reference"></a></span><a class="link" href="traits.html#iterator.utilities.traits.indirect_reference"><code class="computeroutput"><span class="identifier">indirect_reference</span></code></a>
      </h3>
<p>
        <code class="computeroutput"><span class="identifier">indirect_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is rather more specialized than <code class="computeroutput"><span class="identifier">pointee</span></code>, and is meant to be used to forward
        the result of dereferencing an object of its argument type. Most dereferenceable
        types just return a reference to their pointee, but some return proxy references
        or return the pointee by value. When that information is needed, call on
        <code class="computeroutput"><span class="identifier">indirect_reference</span></code>.
      </p>
<p>
        Both of these templates are essential to the correct functioning of <a class="link" href="../specialized/indirect.html" title="Indirect Iterator"><code class="computeroutput"><span class="identifier">indirect_iterator</span></code></a>.
      </p>
<h3>
<a name="iterator.utilities.traits.h3"></a>
        <span class="phrase"><a name="iterator.utilities.traits.minimum_category"></a></span><a class="link" href="traits.html#iterator.utilities.traits.minimum_category"><code class="computeroutput"><span class="identifier">minimum_category</span></code></a>
      </h3>
<p>
        <code class="computeroutput"><span class="identifier">minimum_category</span></code> takes two
        iterator categories or two iterator traversal tags and returns the one that
        is the weakest (i.e. least advanced). For example:
      </p>
<pre class="programlisting"><span class="keyword">static_assert</span><span class="special">(</span>
    <span class="identifier">is_same</span><span class="special">&lt;</span>
        <span class="identifier">minimum_category</span><span class="special">&lt;</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span><span class="special">,</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">random_access_iterator_tag</span>
        <span class="special">&gt;::</span><span class="identifier">type</span><span class="special">,</span>
        <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span>
    <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
    <span class="string">"Unexpected minimum_category result"</span>
<span class="special">);</span>
</pre>
<h3>
<a name="iterator.utilities.traits.h4"></a>
        <span class="phrase"><a name="iterator.utilities.traits.iterator_category_and_traversal_"></a></span><a class="link" href="traits.html#iterator.utilities.traits.iterator_category_and_traversal_">Iterator
        category and traversal tags manipulation</a>
      </h3>
<p>
        The library provides several utilities to simplify conversions between iterator
        categories and traversal tags:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">iterator_category_to_traversal</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
            - the metafunction takes an iterator category <code class="computeroutput"><span class="identifier">C</span></code>
            and returns the corresponding traversal tag.
          </li>
<li class="listitem">
            <code class="computeroutput"><span class="identifier">iterator_traversal</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code> - a shorthand for <code class="computeroutput"><span class="identifier">iterator_category_to_traversal</span><span class="special">&lt;</span><span class="identifier">iterator_category</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
          </li>
<li class="listitem">
            <code class="computeroutput"><span class="identifier">pure_traversal_tag</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code> - the metafunction takes a tag
            <code class="computeroutput"><span class="identifier">T</span></code> which derives from
            one of the iterator traversal tags and returns that traversal tag. <code class="computeroutput"><span class="identifier">T</span></code> may also derive from other tags describing
            the iterator (e.g. whether this is a <code class="computeroutput"><span class="keyword">const</span></code>-iterator
            or not), these additional tags are not considered.
          </li>
<li class="listitem">
            <code class="computeroutput"><span class="identifier">pure_iterator_traversal</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
            - a shorthand for <code class="computeroutput"><span class="identifier">pure_traversal_tag</span><span class="special">&lt;</span><span class="identifier">iterator_traversal</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
          </li>
</ul></div>
<h3>
<a name="iterator.utilities.traits.h5"></a>
        <span class="phrase"><a name="iterator.utilities.traits.reference"></a></span><a class="link" href="traits.html#iterator.utilities.traits.reference">Reference</a>
      </h3>
<h4>
<a name="iterator.utilities.traits.h6"></a>
        <span class="phrase"><a name="iterator.utilities.traits.pointee0"></a></span><a class="link" href="traits.html#iterator.utilities.traits.pointee0"><code class="computeroutput"><span class="identifier">pointee</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Dereferenceable</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">pointee</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="comment">/* see below */</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> For an object <code class="computeroutput"><span class="identifier">x</span></code>
        of type <code class="computeroutput"><span class="identifier">Dereferenceable</span></code>,
        <code class="computeroutput"><span class="special">*</span><span class="identifier">x</span></code>
        is well-formed. If <code class="computeroutput"><span class="special">++</span><span class="identifier">x</span></code>
        is ill-formed it shall neither be ambiguous nor shall it violate access control,
        and <code class="computeroutput"><span class="identifier">Dereferenceable</span><span class="special">::</span><span class="identifier">element_type</span></code> shall be an accessible type.
        Otherwise <code class="computeroutput"><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
        shall be well formed. [Note: These requirements need not apply to explicit
        or partial specializations of <code class="computeroutput"><span class="identifier">pointee</span></code>]
      </p>
<p>
        <code class="computeroutput"><span class="identifier">type</span></code> is determined according
        to the following algorithm, where <code class="computeroutput"><span class="identifier">x</span></code>
        is an object of type <code class="computeroutput"><span class="identifier">Dereferenceable</span></code>:
      </p>
<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span> <span class="special">++</span><span class="identifier">x</span> <span class="identifier">is</span> <span class="identifier">ill</span><span class="special">-</span><span class="identifier">formed</span> <span class="special">)</span>
<span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">Dereferenceable</span><span class="special">::</span><span class="identifier">element_type</span>
<span class="special">}</span>
<span class="keyword">else</span> <span class="keyword">if</span> <span class="special">(*</span><span class="identifier">x</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="keyword">mutable</span> <span class="identifier">reference</span> <span class="identifier">to</span>
         <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">)</span>
<span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">value_type</span>
<span class="special">}</span>
<span class="keyword">else</span>
<span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="keyword">const</span>
<span class="special">}</span>
</pre>
<h4>
<a name="iterator.utilities.traits.h7"></a>
        <span class="phrase"><a name="iterator.utilities.traits.indirect_reference0"></a></span><a class="link" href="traits.html#iterator.utilities.traits.indirect_reference0"><code class="computeroutput"><span class="identifier">indirect_reference</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Dereferenceable</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">indirect_reference</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="comment">/* see below */</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> For an object <code class="computeroutput"><span class="identifier">x</span></code>
        of type <code class="computeroutput"><span class="identifier">Dereferenceable</span></code>,
        <code class="computeroutput"><span class="special">*</span><span class="identifier">x</span></code>
        is well-formed. If <code class="computeroutput"><span class="special">++</span><span class="identifier">x</span></code>
        is ill-formed it shall neither be ambiguous nor shall it violate access control,
        and <code class="computeroutput"><span class="identifier">pointee</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&amp;</span></code>
        shall be well-formed. Otherwise <code class="computeroutput"><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">reference</span></code>
        shall be well formed. [Note: These requirements need not apply to explicit
        or partial specializations of <code class="computeroutput"><span class="identifier">indirect_reference</span></code>]
      </p>
<p>
        <code class="computeroutput"><span class="identifier">type</span></code> is determined according
        to the following algorithm, where <code class="computeroutput"><span class="identifier">x</span></code>
        is an object of type <code class="computeroutput"><span class="identifier">Dereferenceable</span></code>:
      </p>
<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span> <span class="special">++</span><span class="identifier">x</span> <span class="identifier">is</span> <span class="identifier">ill</span><span class="special">-</span><span class="identifier">formed</span> <span class="special">)</span>
    <span class="keyword">return</span> <span class="identifier">pointee</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&amp;</span>
<span class="keyword">else</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Dereferenceable</span><span class="special">&gt;::</span><span class="identifier">reference</span>
</pre>
<h4>
<a name="iterator.utilities.traits.h8"></a>
        <span class="phrase"><a name="iterator.utilities.traits.minimum_category0"></a></span><a class="link" href="traits.html#iterator.utilities.traits.minimum_category0"><code class="computeroutput"><span class="identifier">minimum_category</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C2</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">minimum_category</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="comment">/* see below */</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> Both <code class="computeroutput"><span class="identifier">C1</span></code>
        and <code class="computeroutput"><span class="identifier">C2</span></code> shall be standard
        iterator categories or iterator traversal tags.
      </p>
<p>
        <code class="computeroutput"><span class="identifier">type</span></code> is determined according
        to the following algorithm, where <code class="computeroutput"><span class="identifier">c1</span></code>
        is an object of type <code class="computeroutput"><span class="identifier">C1</span></code> and
        <code class="computeroutput"><span class="identifier">c2</span></code> is an object of type
        <code class="computeroutput"><span class="identifier">C2</span></code>:
      </p>
<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">c1</span> <span class="identifier">is</span> <span class="identifier">convertible</span> <span class="identifier">to</span> <span class="identifier">c2</span><span class="special">)</span>
    <span class="keyword">return</span> <span class="identifier">C2</span><span class="special">;</span>
<span class="keyword">else</span>
    <span class="keyword">return</span> <span class="identifier">C1</span><span class="special">;</span>
</pre>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
          The above definition relies on the fact that the more restricting categories
          and traversal tags are convertible to the less restricting ones.
        </p></td></tr>
</table></div>
<h4>
<a name="iterator.utilities.traits.h9"></a>
        <span class="phrase"><a name="iterator.utilities.traits.iterator_category_to_traversal"></a></span><a class="link" href="traits.html#iterator.utilities.traits.iterator_category_to_traversal"><code class="computeroutput"><span class="identifier">iterator_category_to_traversal</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">iterator_category_to_traversal</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="comment">/* see below */</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">C</span></code>
        shall be a standard iterator category or an iterator traversal tag.
      </p>
<p>
        If <code class="computeroutput"><span class="identifier">C</span></code> is an iterator traversal
        tag or convertible to one, <code class="computeroutput"><span class="identifier">type</span></code>
        equivalent to <code class="computeroutput"><span class="identifier">C</span></code>. Otherwise,
        <code class="computeroutput"><span class="identifier">type</span></code> is defined to the closest
        iterator traversal tag matching <code class="computeroutput"><span class="identifier">C</span></code>.
      </p>
<h4>
<a name="iterator.utilities.traits.h10"></a>
        <span class="phrase"><a name="iterator.utilities.traits.iterator_traversal"></a></span><a class="link" href="traits.html#iterator.utilities.traits.iterator_traversal"><code class="computeroutput"><span class="identifier">iterator_traversal</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">iterator_traversal</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">iterator_category_to_traversal</span><span class="special">&lt;</span>
        <span class="keyword">typename</span> <span class="identifier">iterator_category</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">type</span>
    <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">Iterator</span></code>
        shall be an iterator.
      </p>
<h4>
<a name="iterator.utilities.traits.h11"></a>
        <span class="phrase"><a name="iterator.utilities.traits.pure_traversal_tag"></a></span><a class="link" href="traits.html#iterator.utilities.traits.pure_traversal_tag"><code class="computeroutput"><span class="identifier">pure_traversal_tag</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">pure_traversal_tag</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="comment">/* see below */</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">T</span></code>
        shall be convertible to an iterator traversal tag.
      </p>
<p>
        <code class="computeroutput"><span class="identifier">type</span></code> is defined to be the
        most advanced traversal tag <code class="computeroutput"><span class="identifier">Tag</span></code>
        so that <code class="computeroutput"><span class="identifier">T</span></code> is convertible
        to <code class="computeroutput"><span class="identifier">Tag</span></code>.
      </p>
<h4>
<a name="iterator.utilities.traits.h12"></a>
        <span class="phrase"><a name="iterator.utilities.traits.pure_iterator_traversal"></a></span><a class="link" href="traits.html#iterator.utilities.traits.pure_iterator_traversal"><code class="computeroutput"><span class="identifier">pure_iterator_traversal</span></code></a>
      </h4>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">pure_iterator_traversal</span>
<span class="special">{</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">pure_traversal_tag</span><span class="special">&lt;</span>
        <span class="keyword">typename</span> <span class="identifier">iterator_traversal</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">type</span>
    <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
        <span class="bold"><strong>Requires:</strong></span> <code class="computeroutput"><span class="identifier">Iterator</span></code>
        shall be an iterator.
      </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2003, 2005 David Abrahams Jeremy Siek Thomas
      Witt<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at &lt;ulink url="http://www.boost.org/LICENSE_1_0.txt"&gt;
        http://www.boost.org/LICENSE_1_0.txt &lt;/ulink&gt;)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="iterator_traits.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../utilities.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../algorithms.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
